/**
 * @fileoverview Tests for writer.js.
 */
goog.module('protobuf.binary.WriterTest');

goog.setTestOnly();

// Note to the reader:
// Since the writer behavior changes with the checking level some of the tests
// in this file have to know which checking level is enable to make correct
// assertions.
const BufferDecoder = goog.require('protobuf.binary.BufferDecoder');
const ByteString = goog.require('protobuf.ByteString');
const WireType = goog.require('protobuf.binary.WireType');
const Writer = goog.require('protobuf.binary.Writer');
const {CHECK_BOUNDS, CHECK_TYPE, MAX_FIELD_NUMBER} = goog.require('protobuf.internal.checks');
const {arrayBufferSlice} = goog.require('protobuf.binary.typedArrays');
const {getDoublePairs} = goog.require('protobuf.binary.doubleTestPairs');
const {getFixed32Pairs} = goog.require('protobuf.binary.fixed32TestPairs');
const {getFloatPairs} = goog.require('protobuf.binary.floatTestPairs');
const {getInt32Pairs} = goog.require('protobuf.binary.int32TestPairs');
const {getInt64Pairs} = goog.require('protobuf.binary.int64TestPairs');
const {getPackedBoolPairs} = goog.require('protobuf.binary.packedBoolTestPairs');
const {getPackedDoublePairs} = goog.require('protobuf.binary.packedDoubleTestPairs');
const {getPackedFixed32Pairs} = goog.require('protobuf.binary.packedFixed32TestPairs');
const {getPackedFloatPairs} = goog.require('protobuf.binary.packedFloatTestPairs');
const {getPackedInt32Pairs} = goog.require('protobuf.binary.packedInt32TestPairs');
const {getPackedInt64Pairs} = goog.require('protobuf.binary.packedInt64TestPairs');
const {getPackedSfixed32Pairs} = goog.require('protobuf.binary.packedSfixed32TestPairs');
const {getPackedSfixed64Pairs} = goog.require('protobuf.binary.packedSfixed64TestPairs');
const {getPackedSint32Pairs} = goog.require('protobuf.binary.packedSint32TestPairs');
const {getPackedSint64Pairs} = goog.require('protobuf.binary.packedSint64TestPairs');
const {getPackedUint32Pairs} = goog.require('protobuf.binary.packedUint32TestPairs');
const {getSfixed32Pairs} = goog.require('protobuf.binary.sfixed32TestPairs');
const {getSfixed64Pairs} = goog.require('protobuf.binary.sfixed64TestPairs');
const {getSint32Pairs} = goog.require('protobuf.binary.sint32TestPairs');
const {getSint64Pairs} = goog.require('protobuf.binary.sint64TestPairs');
const {getUint32Pairs} = goog.require('protobuf.binary.uint32TestPairs');


/**
 * @param {...number} bytes
 * @return {!ArrayBuffer}
 */
function createArrayBuffer(...bytes) {
    return new Uint8Array(bytes).buffer;
}

/******************************************************************************
 *                        OPTIONAL FUNCTIONS
 ******************************************************************************/

describe('Writer does', () => {
    it('return an empty ArrayBuffer when nothing is encoded', () => {
        const writer = new Writer();
        expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
    });

    it('encode tag', () => {
        const writer = new Writer();
        writer.writeTag(1, WireType.VARINT);
        expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer(0x08));

        writer.writeTag(0x0FFFFFFF, WireType.VARINT);
        expect(writer.getAndResetResultBuffer())
            .toEqual(createArrayBuffer(0xF8, 0xFF, 0xFF, 0xFF, 0x7));

        writer.writeTag(0x10000000, WireType.VARINT);
        expect(writer.getAndResetResultBuffer())
            .toEqual(createArrayBuffer(0x80, 0x80, 0x80, 0x80, 0x08));

        writer.writeTag(0x1FFFFFFF, WireType.VARINT);
        expect(writer.getAndResetResultBuffer())
            .toEqual(createArrayBuffer(0xF8, 0xFF, 0xFF, 0xFF, 0x0F));
    });

    it('reset after calling getAndResetResultBuffer', () => {
        const writer = new Writer();
        writer.writeTag(1, WireType.VARINT);
        writer.getAndResetResultBuffer();
        expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
    });

    it('fail when field number is too large for writeTag', () => {
        const writer = new Writer();
        if (CHECK_TYPE) {
            expect(() => writer.writeTag(MAX_FIELD_NUMBER + 1, WireType.VARINT))
                .toThrowError('Field number is out of range: 536870912');
        } else {
            // Note in unchecked mode we produce invalid output for invalid inputs.
            // This test just documents our behavior in those cases.
            // These values might change at any point and are not considered
            // what the implementation should be doing here.
            writer.writeTag(MAX_FIELD_NUMBER + 1, WireType.VARINT);
            expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer(0));
        }
    });

    it('fail when field number is negative for writeTag', () => {
        const writer = new Writer();
        if (CHECK_TYPE) {
            expect(() => writer.writeTag(-1, WireType.VARINT))
                .toThrowError('Field number is out of range: -1');
        } else {
            // Note in unchecked mode we produce invalid output for invalid inputs.
            // This test just documents our behavior in those cases.
            // These values might change at any point and are not considered
            // what the implementation should be doing here.
            writer.writeTag(-1, WireType.VARINT);
            expect(writer.getAndResetResultBuffer())
                .toEqual(createArrayBuffer(0xF8, 0xFF, 0xFF, 0xFF, 0xF));
        }
    });

    it('fail when wire type is invalid for writeTag', () => {
        const writer = new Writer();
        if (CHECK_TYPE) {
            expect(() => writer.writeTag(1, /** @type {!WireType} */ (0x08)))
                .toThrowError('Invalid wire type: 8');
        } else {
            // Note in unchecked mode we produce invalid output for invalid inputs.
            // This test just documents our behavior in those cases.
            // These values might change at any point and are not considered
            // what the implementation should be doing here.
            writer.writeTag(1, /** @type {!WireType} */ (0x08));
            expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer(0x08));
        }
    });

    it('encode singular boolean value', () => {
        const writer = new Writer();
        writer.writeBool(1, true);
        expect(writer.getAndResetResultBuffer())
            .toEqual(createArrayBuffer(0x08, 0x01));
    });

    it('encode length delimited', () => {
        const writer = new Writer();
        writer.writeDelimited(1, createArrayBuffer(0x01, 0x02));
        expect(writer.getAndResetResultBuffer())
            .toEqual(createArrayBuffer(0x0A, 0x02, 0x01, 0x02));
    });
});

describe('Writer.writeBufferDecoder does', () => {
    it('encode BufferDecoder containing a varint value', () => {
        const writer = new Writer();
        const expected = createArrayBuffer(
            0x08, /* varint start= */ 0xFF, /* varint end= */ 0x01, 0x08, 0x01);
        writer.writeBufferDecoder(
            BufferDecoder.fromArrayBuffer(expected), 1, WireType.VARINT, 1);
        const result = writer.getAndResetResultBuffer();
        expect(result).toEqual(arrayBufferSlice(expected, 1, 3));
    });

    it('encode BufferDecoder containing a fixed64 value', () => {
        const writer = new Writer();
        const expected = createArrayBuffer(
            0x09, /* fixed64 start= */ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
            /* fixed64 end= */ 0x08, 0x08, 0x01);
        writer.writeBufferDecoder(
            BufferDecoder.fromArrayBuffer(expected), 1, WireType.FIXED64, 1);
        const result = writer.getAndResetResultBuffer();
        expect(result).toEqual(arrayBufferSlice(expected, 1, 9));
    });

    it('encode BufferDecoder containing a length delimited value', () => {
        const writer = new Writer();
        const expected = createArrayBuffer(
            0xA, /* length= */ 0x03, /* data start= */ 0x01, 0x02,
            /* data end= */ 0x03, 0x08, 0x01);
        writer.writeBufferDecoder(
            BufferDecoder.fromArrayBuffer(expected), 1, WireType.DELIMITED, 1);
        const result = writer.getAndResetResultBuffer();
        expect(result).toEqual(arrayBufferSlice(expected, 1, 5));
    });

    it('encode BufferDecoder containing a group', () => {
        const writer = new Writer();
        const expected = createArrayBuffer(
            0xB, /* group start= */ 0x08, 0x01, /* nested group start= */ 0x0B,
            /* nested group end= */ 0x0C, /* group end= */ 0x0C, 0x08, 0x01);
        writer.writeBufferDecoder(
            BufferDecoder.fromArrayBuffer(expected), 1, WireType.START_GROUP, 1);
        const result = writer.getAndResetResultBuffer();
        expect(result).toEqual(arrayBufferSlice(expected, 1, 6));
    });

    it('encode BufferDecoder containing a fixed32 value', () => {
        const writer = new Writer();
        const expected = createArrayBuffer(
            0x09, /* fixed64 start= */ 0x01, 0x02, 0x03, /* fixed64 end= */ 0x04,
            0x08, 0x01);
        writer.writeBufferDecoder(
            BufferDecoder.fromArrayBuffer(expected), 1, WireType.FIXED32, 1);
        const result = writer.getAndResetResultBuffer();
        expect(result).toEqual(arrayBufferSlice(expected, 1, 5));
    });

    it('fail when encoding out of bound data', () => {
        const writer = new Writer();
        const buffer = createArrayBuffer(0x4, 0x0, 0x1, 0x2, 0x3);
        const subBuffer = arrayBufferSlice(buffer, 0, 2);
        expect(
            () => writer.writeBufferDecoder(
                BufferDecoder.fromArrayBuffer(subBuffer), 0, WireType.DELIMITED, 1))
            .toThrow();
    });
});

describe('Writer.writeBytes does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    it('encodes empty ByteString', () => {
        writer.writeBytes(1, ByteString.EMPTY);
        const buffer = writer.getAndResetResultBuffer();
        expect(buffer.byteLength).toBe(2);
    });

    it('encodes empty array', () => {
        writer.writeBytes(1, ByteString.fromArrayBuffer(new ArrayBuffer(0)));
        expect(writer.getAndResetResultBuffer())
            .toEqual(createArrayBuffer(
                1 << 3 | 0x02,  // tag (fieldnumber << 3 | (length delimited))
                0,              // length of the bytes
            ));
    });

    it('encodes ByteString', () => {
        const array = createArrayBuffer(1, 2, 3);
        writer.writeBytes(1, ByteString.fromArrayBuffer(array));
        expect(writer.getAndResetResultBuffer())
            .toEqual(createArrayBuffer(
                1 << 3 | 0x02,  // tag (fieldnumber << 3 | (length delimited))
                3,              // length of the bytes
                1,
                2,
                3,
            ));
    });
});

describe('Writer.writeDouble does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    for (const pair of getDoublePairs()) {
        it(`encode ${pair.name}`, () => {
            writer.writeDouble(1, pair.doubleValue);
            const buffer = new Uint8Array(writer.getAndResetResultBuffer());
            expect(buffer.length).toBe(9);
            // ensure we have a correct tag
            expect(buffer[0]).toEqual(0x09);
            // Encoded values are stored right after the tag
            expect(buffer.subarray(1, 9))
                .toEqual(pair.bufferDecoder.asUint8Array());
        });
    }

    /**
     * NaN may have different value in different browsers. Thus, we need to make
     * the test lenient.
     */
    it('encode NaN', () => {
        writer.writeDouble(1, NaN);
        const buffer = new Uint8Array(writer.getAndResetResultBuffer());
        expect(buffer.length).toBe(9);
        // ensure we have a correct tag
        expect(buffer[0]).toEqual(0x09);
        // Encoded values are stored right after the tag
        const float64 = new DataView(buffer.buffer);
        expect(float64.getFloat64(1, true)).toBeNaN();
    });
});

describe('Writer.writeFixed32 does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    for (const pair of getFixed32Pairs()) {
        it(`encode ${pair.name}`, () => {
            writer.writeFixed32(1, pair.intValue);
            const buffer = new Uint8Array(writer.getAndResetResultBuffer());
            expect(buffer.length).toBe(5);
            // ensure we have a correct tag
            expect(buffer[0]).toEqual(0x0D);
            // Encoded values are stored right after the tag
            expect(buffer.subarray(1, 5)).toEqual(pair.bufferDecoder.asUint8Array());
        });
    }
});

describe('Writer.writeFloat does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    for (const pair of getFloatPairs()) {
        it(`encode ${pair.name}`, () => {
            writer.writeFloat(1, pair.floatValue);
            const buffer = new Uint8Array(writer.getAndResetResultBuffer());
            expect(buffer.length).toBe(5);
            // ensure we have a correct tag
            expect(buffer[0]).toEqual(0x0D);
            // Encoded values are stored right after the tag
            expect(buffer.subarray(1, 5)).toEqual(pair.bufferDecoder.asUint8Array());
        });
    }

    /**
     * NaN may have different value in different browsers. Thus, we need to make
     * the test lenient.
     */
    it('encode NaN', () => {
        writer.writeFloat(1, NaN);
        const buffer = new Uint8Array(writer.getAndResetResultBuffer());
        expect(buffer.length).toBe(5);
        // ensure we have a correct tag
        expect(buffer[0]).toEqual(0x0D);
        // Encoded values are stored right after the tag
        const float32 = new DataView(buffer.buffer);
        expect(float32.getFloat32(1, true)).toBeNaN();
    });
});

describe('Writer.writeInt32 does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    for (const pair of getInt32Pairs()) {
        if (!pair.skip_writer) {
            it(`encode ${pair.name}`, () => {
                writer.writeInt32(1, pair.intValue);
                const buffer = new Uint8Array(writer.getAndResetResultBuffer());
                // ensure we have a correct tag
                expect(buffer[0]).toEqual(0x08);
                // Encoded values are stored right after the tag
                expect(buffer.subarray(1, buffer.length))
                    .toEqual(pair.bufferDecoder.asUint8Array());
            });
        }
    }
});

describe('Writer.writeSfixed32 does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    it('encode empty array', () => {
        writer.writePackedSfixed32(1, []);
        expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
    });

    for (const pair of getSfixed32Pairs()) {
        it(`encode ${pair.name}`, () => {
            writer.writeSfixed32(1, pair.intValue);
            const buffer = new Uint8Array(writer.getAndResetResultBuffer());
            expect(buffer.length).toBe(5);
            // ensure we have a correct tag
            expect(buffer[0]).toEqual(0x0D);
            // Encoded values are stored right after the tag
            expect(buffer.subarray(1, 5)).toEqual(pair.bufferDecoder.asUint8Array());
        });
    }
});

describe('Writer.writeSfixed64 does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    for (const pair of getSfixed64Pairs()) {
        it(`encode ${pair.name}`, () => {
            writer.writeSfixed64(1, pair.longValue);
            const buffer = new Uint8Array(writer.getAndResetResultBuffer());
            expect(buffer.length).toBe(9);
            // ensure we have a correct tag
            expect(buffer[0]).toEqual(0x09);
            // Encoded values are stored right after the tag
            expect(buffer.subarray(1, 9)).toEqual(pair.bufferDecoder.asUint8Array());
        });
    }
});

describe('Writer.writeSint32 does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    for (const pair of getSint32Pairs()) {
        if (!pair.skip_writer) {
            it(`encode ${pair.name}`, () => {
                writer.writeSint32(1, pair.intValue);
                const buffer = new Uint8Array(writer.getAndResetResultBuffer());
                // ensure we have a correct tag
                expect(buffer[0]).toEqual(0x08);
                // Encoded values are stored right after the tag
                expect(buffer.subarray(1, buffer.length))
                    .toEqual(pair.bufferDecoder.asUint8Array());
            });
        }
    }
});

describe('Writer.writeSint64 does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    for (const pair of getSint64Pairs()) {
        if (!pair.skip_writer) {
            it(`encode ${pair.name}`, () => {
                writer.writeSint64(1, pair.longValue);
                const buffer = new Uint8Array(writer.getAndResetResultBuffer());
                // ensure we have a correct tag
                expect(buffer[0]).toEqual(0x08);
                // Encoded values are stored right after the tag
                expect(buffer.subarray(1, buffer.length))
                    .toEqual(pair.bufferDecoder.asUint8Array());
            });
        }
    }
});

describe('Writer.writeInt64 does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    for (const pair of getInt64Pairs()) {
        if (!pair.skip_writer) {
            it(`encode ${pair.name}`, () => {
                writer.writeInt64(1, pair.longValue);
                const buffer = new Uint8Array(writer.getAndResetResultBuffer());
                // ensure we have a correct tag
                expect(buffer[0]).toEqual(0x08);
                // Encoded values are stored right after the tag
                expect(buffer.subarray(1, buffer.length))
                    .toEqual(pair.bufferDecoder.asUint8Array());
            });
        }
    }
});

describe('Writer.writeUint32 does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    for (const pair of getUint32Pairs()) {
        if (!pair.skip_writer) {
            it(`encode ${pair.name}`, () => {
                writer.writeUint32(1, pair.intValue);
                const buffer = new Uint8Array(writer.getAndResetResultBuffer());
                // ensure we have a correct tag
                expect(buffer[0]).toEqual(0x08);
                // Encoded values are stored right after the tag
                expect(buffer.subarray(1, buffer.length))
                    .toEqual(pair.bufferDecoder.asUint8Array());
            });
        }
    }
});

describe('Writer.writeString does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    it('encode empty string', () => {
        writer.writeString(1, '');
        expect(writer.getAndResetResultBuffer())
            .toEqual(createArrayBuffer(
                1 << 3 | 0x02,  // tag (fieldnumber << 3 | (length delimited))
                0,              // length of the string
            ));
    });

    it('encode simple string', () => {
        writer.writeString(1, 'hello');
        expect(writer.getAndResetResultBuffer())
            .toEqual(createArrayBuffer(
                1 << 3 | 0x02,  // tag (fieldnumber << 3 | (length delimited))
                5,              // length of the string
                'h'.charCodeAt(0),
                'e'.charCodeAt(0),
                'l'.charCodeAt(0),
                'l'.charCodeAt(0),
                'o'.charCodeAt(0),
            ));
    });

    it('throw for invalid fieldnumber', () => {
        if (CHECK_BOUNDS) {
            expect(() => writer.writeString(-1, 'a'))
                .toThrowError('Field number is out of range: -1');
        } else {
            writer.writeString(-1, 'a');
            expect(new Uint8Array(writer.getAndResetResultBuffer()))
                .toEqual(new Uint8Array(createArrayBuffer(
                    -6,  // invalid tag
                    0xff,
                    0xff,
                    0xff,
                    0x0f,
                    1,  // string length
                    'a'.charCodeAt(0),
                )));
        }
    });

    it('throw for null string value', () => {
        expect(
            () => writer.writeString(
                1, /** @type {string} */ (/** @type {*} */ (null))))
            .toThrow();
    });
});


/******************************************************************************
 *                        REPEATED FUNCTIONS
 ******************************************************************************/

describe('Writer.writePackedBool does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    it('encode empty array', () => {
        writer.writePackedBool(1, []);
        expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
    });

    for (const pair of getPackedBoolPairs()) {
        if (!pair.skip_writer) {
            it(`encode ${pair.name}`, () => {
                writer.writePackedBool(1, pair.boolValues);
                const buffer = new Uint8Array(writer.getAndResetResultBuffer());
                // ensure we have a correct tag
                expect(buffer[0]).toEqual(0x0A);
                // Encoded values are stored right after the tag
                expect(buffer.subarray(1, buffer.length))
                    .toEqual(pair.bufferDecoder.asUint8Array());
            });
        }
    }
});

describe('Writer.writeRepeatedBool does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    it('encode empty array', () => {
        writer.writeRepeatedBool(1, []);
        expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
    });

    it('encode repeated unpacked boolean values', () => {
        const writer = new Writer();
        writer.writeRepeatedBool(1, [true, false]);
        expect(writer.getAndResetResultBuffer())
            .toEqual(createArrayBuffer(
                1 << 3 | 0x00,  // tag (fieldnumber << 3 | (varint))
                0x01,           // value[0]
                1 << 3 | 0x00,  // tag (fieldnumber << 3 | (varint))
                0x00,           // value[1]
            ));
    });
});

describe('Writer.writePackedDouble does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    it('encode empty array', () => {
        writer.writePackedDouble(1, []);
        expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
    });

    for (const pair of getPackedDoublePairs()) {
        if (!pair.skip_writer) {
            it(`encode ${pair.name}`, () => {
                writer.writePackedDouble(1, pair.doubleValues);
                const buffer = new Uint8Array(writer.getAndResetResultBuffer());
                // ensure we have a correct tag
                expect(buffer[0]).toEqual(0x0A);
                // Encoded values are stored right after the tag
                expect(buffer.subarray(1, buffer.length))
                    .toEqual(pair.bufferDecoder.asUint8Array());
            });
        }
    }
});

describe('Writer.writePackedFixed32 does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    it('encode empty array', () => {
        writer.writePackedFixed32(1, []);
        expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
    });

    for (const pair of getPackedFixed32Pairs()) {
        if (!pair.skip_writer) {
            it(`encode ${pair.name}`, () => {
                writer.writePackedFixed32(1, pair.fixed32Values);
                const buffer = new Uint8Array(writer.getAndResetResultBuffer());
                // ensure we have a correct tag
                expect(buffer[0]).toEqual(0x0A);
                // Encoded values are stored right after the tag
                expect(buffer.subarray(1, buffer.length))
                    .toEqual(pair.bufferDecoder.asUint8Array());
            });
        }
    }
});

describe('Writer.writePackedFloat does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    it('encode empty array', () => {
        writer.writePackedFloat(1, []);
        expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
    });

    for (const pair of getPackedFloatPairs()) {
        if (!pair.skip_writer) {
            it(`encode ${pair.name}`, () => {
                writer.writePackedFloat(1, pair.floatValues);
                const buffer = new Uint8Array(writer.getAndResetResultBuffer());
                // ensure we have a correct tag
                expect(buffer[0]).toEqual(0x0A);
                // Encoded values are stored right after the tag
                expect(buffer.subarray(1, buffer.length))
                    .toEqual(pair.bufferDecoder.asUint8Array());
            });
        }
    }
});

describe('Writer.writePackedInt32 does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    it('encode empty array', () => {
        writer.writePackedInt32(1, []);
        expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
    });

    for (const pair of getPackedInt32Pairs()) {
        if (!pair.skip_writer) {
            it(`encode ${pair.name}`, () => {
                writer.writePackedInt32(1, pair.int32Values);
                const buffer = new Uint8Array(writer.getAndResetResultBuffer());
                // ensure we have a correct tag
                expect(buffer[0]).toEqual(0x0A);
                // Encoded values are stored right after the tag
                expect(buffer.subarray(1, buffer.length))
                    .toEqual(pair.bufferDecoder.asUint8Array());
            });
        }
    }
});

describe('Writer.writePackedInt64 does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    it('encode empty array', () => {
        writer.writePackedInt64(1, []);
        expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
    });

    for (const pair of getPackedInt64Pairs()) {
        if (!pair.skip_writer) {
            it(`encode ${pair.name}`, () => {
                writer.writePackedInt64(1, pair.int64Values);
                const buffer = new Uint8Array(writer.getAndResetResultBuffer());
                // ensure we have a correct tag
                expect(buffer[0]).toEqual(0x0A);
                // Encoded values are stored right after the tag
                expect(buffer.subarray(1, buffer.length))
                    .toEqual(pair.bufferDecoder.asUint8Array());
            });
        }
    }
});

describe('Writer.writePackedSfixed32 does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    it('encode empty array', () => {
        writer.writePackedSfixed32(1, []);
        expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
    });

    for (const pair of getPackedSfixed32Pairs()) {
        if (!pair.skip_writer) {
            it(`encode ${pair.name}`, () => {
                writer.writePackedSfixed32(1, pair.sfixed32Values);
                const buffer = new Uint8Array(writer.getAndResetResultBuffer());
                // ensure we have a correct tag
                expect(buffer[0]).toEqual(0x0A);
                // Encoded values are stored right after the tag
                expect(buffer.subarray(1, buffer.length))
                    .toEqual(pair.bufferDecoder.asUint8Array());
            });
        }
    }
});

describe('Writer.writePackedSfixed64 does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    it('encode empty array', () => {
        writer.writePackedSfixed64(1, []);
        expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
    });

    for (const pair of getPackedSfixed64Pairs()) {
        if (!pair.skip_writer) {
            it(`encode ${pair.name}`, () => {
                writer.writePackedSfixed64(1, pair.sfixed64Values);
                const buffer = new Uint8Array(writer.getAndResetResultBuffer());
                // ensure we have a correct tag
                expect(buffer[0]).toEqual(0x0A);
                // Encoded values are stored right after the tag
                expect(buffer.subarray(1, buffer.length))
                    .toEqual(pair.bufferDecoder.asUint8Array());
            });
        }
    }
});

describe('Writer.writePackedSint32 does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    it('encode empty array', () => {
        writer.writePackedSint32(1, []);
        expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
    });

    for (const pair of getPackedSint32Pairs()) {
        if (!pair.skip_writer) {
            it(`encode ${pair.name}`, () => {
                writer.writePackedSint32(1, pair.sint32Values);
                const buffer = new Uint8Array(writer.getAndResetResultBuffer());
                // ensure we have a correct tag
                expect(buffer[0]).toEqual(0x0A);
                // Encoded values are stored right after the tag
                expect(buffer.subarray(1, buffer.length))
                    .toEqual(pair.bufferDecoder.asUint8Array());
            });
        }
    }
});

describe('Writer.writePackedSint64 does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    it('encode empty array', () => {
        writer.writePackedSint64(1, []);
        expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
    });

    for (const pair of getPackedSint64Pairs()) {
        if (!pair.skip_writer) {
            it(`encode ${pair.name}`, () => {
                writer.writePackedSint64(1, pair.sint64Values);
                const buffer = new Uint8Array(writer.getAndResetResultBuffer());
                // ensure we have a correct tag
                expect(buffer[0]).toEqual(0x0A);
                // Encoded values are stored right after the tag
                expect(buffer.subarray(1, buffer.length))
                    .toEqual(pair.bufferDecoder.asUint8Array());
            });
        }
    }
});

describe('Writer.writePackedUint32 does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    it('encode empty array', () => {
        writer.writePackedUint32(1, []);
        expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
    });

    for (const pair of getPackedUint32Pairs()) {
        if (!pair.skip_writer) {
            it(`encode ${pair.name}`, () => {
                writer.writePackedUint32(1, pair.uint32Values);
                const buffer = new Uint8Array(writer.getAndResetResultBuffer());
                // ensure we have a correct tag
                expect(buffer[0]).toEqual(0x0A);
                // Encoded values are stored right after the tag
                expect(buffer.subarray(1, buffer.length))
                    .toEqual(pair.bufferDecoder.asUint8Array());
            });
        }
    }
});

describe('Writer.writeRepeatedBytes does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    it('encode empty array', () => {
        writer.writeRepeatedBytes(1, []);
        expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
    });

    it('encode single value', () => {
        const value = createArrayBuffer(0x61);
        writer.writeRepeatedBytes(1, [ByteString.fromArrayBuffer(value)]);
        expect(writer.getAndResetResultBuffer())
            .toEqual(createArrayBuffer(
                0x0A,
                0x01,
                0x61,  // a
            ));
    });

    it('encode multiple values', () => {
        const value1 = createArrayBuffer(0x61);
        const value2 = createArrayBuffer(0x62);
        writer.writeRepeatedBytes(1, [
            ByteString.fromArrayBuffer(value1),
            ByteString.fromArrayBuffer(value2),
        ]);
        expect(writer.getAndResetResultBuffer())
            .toEqual(createArrayBuffer(
                0x0A,
                0x01,
                0x61,  // a
                0x0A,
                0x01,
                0x62,  // b
            ));
    });
});

describe('Writer.writeRepeatedString does', () => {
    let writer;
    beforeEach(() => {
        writer = new Writer();
    });

    it('encode empty array', () => {
        writer.writeRepeatedString(1, []);
        expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
    });

    it('encode single value', () => {
        writer.writeRepeatedString(1, ['a']);
        expect(writer.getAndResetResultBuffer())
            .toEqual(createArrayBuffer(
                0x0A,
                0x01,
                0x61,  // a
            ));
    });

    it('encode multiple values', () => {
        writer.writeRepeatedString(1, ['a', 'b']);
        expect(writer.getAndResetResultBuffer())
            .toEqual(createArrayBuffer(
                0x0A,
                0x01,
                0x61,  // a
                0x0A,
                0x01,
                0x62,  // b
            ));
    });
});
